package com.gzc.just.play.last.war.sceneserver.attribute;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 英雄属性管理器 - 管理英雄的所有属性
 *
 * 功能：
 * - 基础属性的存储和查询
 * - 属性修改器的应用和管理
 * - 属性变化事件通知
 * - 属性计算和转换
 *
 * 对应C++的 SSGUParameterMgr
 *
 * @author AI编程助手
 * @version 1.0
 * @since 2025-11-22
 */
public class HeroAttribute {
    
    private static final Logger log = LoggerFactory.getLogger(HeroAttribute.class);
    
    private final long objectId;
    private final Map<AttributeType, AttributeValue> attributes = new HashMap<>();
    private final List<AttributeModifier> modifiers = new CopyOnWriteArrayList<>();
    private final List<AttributeListener> listeners = new CopyOnWriteArrayList<>();
    private long lastUpdateTime;
    
    /**
     * 创建英雄属性管理器
     *
     * @param objectId 对象ID
     */
    public HeroAttribute(long objectId) {
        this.objectId = objectId;
        this.lastUpdateTime = System.currentTimeMillis();
        initializeDefaultAttributes();
    }
    
    /**
     * 初始化默认属性
     */
    private void initializeDefaultAttributes() {
        // 等级
        setAttribute(AttributeType.LEVEL, 1);
        setAttribute(AttributeType.EXPERIENCE, 0);
        
        // 生命值
        setAttribute(AttributeType.MAX_HEALTH, 1000);
        setAttribute(AttributeType.CURRENT_HEALTH, 1000);
        setAttribute(AttributeType.HEALTH_RECOVER_RATE, 10); // 每秒恢复10血
        setAttribute(AttributeType.HEALTH_RECOVER_DELAY, 5000); // 5秒无伤后恢复
        
        // 魔力
        setAttribute(AttributeType.MAX_MANA, 500);
        setAttribute(AttributeType.CURRENT_MANA, 500);
        setAttribute(AttributeType.MANA_RECOVER_RATE, 5); // 每秒恢复5魔
        setAttribute(AttributeType.MANA_RECOVER_DELAY, 3000); // 3秒无消耗后恢复
        
        // 攻防速
        setAttribute(AttributeType.ATTACK, 100);
        setAttribute(AttributeType.DEFENSE, 50);
        setAttribute(AttributeType.SPEED, 100);
        
        // 战斗属性
        setAttribute(AttributeType.CRITICAL_RATE, 0.1); // 10%
        setAttribute(AttributeType.CRITICAL_DAMAGE, 1.5); // 150%
        setAttribute(AttributeType.DODGE_RATE, 0.05); // 5%
        setAttribute(AttributeType.DAMAGE_REDUCE_RATE, 0.0); // 0%
        
        // 资源
        setAttribute(AttributeType.GOLD, 0);
        setAttribute(AttributeType.GEMS, 0);
        
        // 统计
        setAttribute(AttributeType.TOTAL_KILLS, 0);
        setAttribute(AttributeType.TOTAL_DEATHS, 0);
        setAttribute(AttributeType.TOTAL_ASSISTS, 0);
        setAttribute(AttributeType.CURRENT_KILL_STREAK, 0);
        
        // 其他
        setAttribute(AttributeType.ARMOR_PENETRATION, 0.0);
        setAttribute(AttributeType.LIFE_STEAL_RATE, 0.0);
        setAttribute(AttributeType.TENACITY, 0.0); // 抗性
    }
    
    /**
     * 设置属性值
     *
     * @param type 属性类型
     * @param value 属性值
     */
    public void setAttribute(AttributeType type, double value) {
        AttributeValue attrValue;
        if (attributes.containsKey(type)) {
            attrValue = attributes.get(type);
            double oldValue = attrValue.getFinalValue();
            attrValue.setBaseValue(value);
            notifyAttributeChanged(type, oldValue, attrValue.getFinalValue());
        } else {
            attrValue = new AttributeValue(type, value);
            attributes.put(type, attrValue);
        }
    }
    
    /**
     * 获取属性值（最终值，包含修改器）
     *
     * @param type 属性类型
     * @return 属性值
     */
    public double getAttribute(AttributeType type) {
        AttributeValue value = attributes.get(type);
        if (value == null) {
            log.warn("属性未找到: {}", type.getDisplayName());
            return 0;
        }
        return value.getFinalValue();
    }
    
    /**
     * 获取属性值（整数形式）
     */
    public int getAttributeAsInt(AttributeType type) {
        return (int) getAttribute(type);
    }
    
    /**
     * 获取基础属性值（不含修改器）
     */
    public double getBaseAttribute(AttributeType type) {
        AttributeValue value = attributes.get(type);
        if (value == null) {
            return 0;
        }
        return value.getBaseValue();
    }
    
    /**
     * 修改属性（相对值）
     *
     * @param type 属性类型
     * @param delta 变化量
     */
    public void modifyAttribute(AttributeType type, double delta) {
        AttributeValue value = attributes.get(type);
        if (value == null) {
            log.warn("属性未找到: {}", type.getDisplayName());
            return;
        }
        
        double oldValue = value.getFinalValue();
        value.setBaseValue(value.getBaseValue() + delta);
        notifyAttributeChanged(type, oldValue, value.getFinalValue());
    }
    
    /**
     * 应用属性修改器
     *
     * @param modifier 属性修改器
     */
    public void applyModifier(AttributeModifier modifier) {
        if (modifier == null) {
            log.warn("试图应用空修改器");
            return;
        }
        
        AttributeType type = modifier.getAttributeType();
        AttributeValue value = attributes.get(type);
        if (value == null) {
            log.warn("属性未找到: {}", type.getDisplayName());
            return;
        }
        
        double oldValue = value.getFinalValue();
        
        // 应用修改器
        modifiers.add(modifier);
        
        // 根据修改器类型应用修改
        switch (modifier.getModifierType()) {
            case FIXED_VALUE:
                value.addModificationValue(modifier.getValue());
                break;
            case PERCENT:
                value.addPercentModification(modifier.getPercentValue());
                break;
            case MIXED:
                value.addModificationValue(modifier.getValue());
                value.addPercentModification(modifier.getPercentValue());
                break;
        }
        
        log.debug("应用修改器 '{}' 到属性 '{}'", modifier.getName(), type.getDisplayName());
        notifyModifierApplied(modifier, true);
        notifyAttributeChanged(type, oldValue, value.getFinalValue());
    }
    
    /**
     * 移除属性修改器
     *
     * @param modifierId 修改器ID
     */
    public void removeModifier(String modifierId) {
        for (AttributeModifier modifier : modifiers) {
            if (modifier.getId().equals(modifierId)) {
                removeModifier(modifier);
                return;
            }
        }
    }
    
    /**
     * 移除属性修改器
     */
    public void removeModifier(AttributeModifier modifier) {
        if (modifiers.remove(modifier)) {
            AttributeType type = modifier.getAttributeType();
            AttributeValue value = attributes.get(type);
            if (value != null) {
                double oldValue = value.getFinalValue();
                
                // 反向应用修改
                switch (modifier.getModifierType()) {
                    case FIXED_VALUE:
                        value.addModificationValue(-modifier.getValue());
                        break;
                    case PERCENT:
                        value.addPercentModification(-modifier.getPercentValue());
                        break;
                    case MIXED:
                        value.addModificationValue(-modifier.getValue());
                        value.addPercentModification(-modifier.getPercentValue());
                        break;
                }
                
                log.debug("移除修改器 '{}' 从属性 '{}'", modifier.getName(), type.getDisplayName());
                notifyModifierApplied(modifier, false);
                notifyAttributeChanged(type, oldValue, value.getFinalValue());
            }
        }
    }
    
    /**
     * 更新属性修改器（移除过期的）
     *
     * @param currentTime 当前时间
     */
    public void updateModifiers(long currentTime) {
        List<AttributeModifier> toRemove = new ArrayList<>();
        
        for (AttributeModifier modifier : modifiers) {
            if (!modifier.update(currentTime)) {
                toRemove.add(modifier);
            }
        }
        
        for (AttributeModifier modifier : toRemove) {
            removeModifier(modifier);
        }
    }
    
    /**
     * 获取所有活跃的修改器
     */
    public List<AttributeModifier> getActiveModifiers() {
        List<AttributeModifier> active = new ArrayList<>();
        for (AttributeModifier modifier : modifiers) {
            if (!modifier.isExpired()) {
                active.add(modifier);
            }
        }
        return active;
    }
    
    /**
     * 获取特定属性类型的修改器
     */
    public List<AttributeModifier> getModifiersForAttribute(AttributeType type) {
        List<AttributeModifier> result = new ArrayList<>();
        for (AttributeModifier modifier : modifiers) {
            if (modifier.getAttributeType() == type && !modifier.isExpired()) {
                result.add(modifier);
            }
        }
        return result;
    }
    
    /**
     * 清除所有修改器
     */
    public void clearAllModifiers() {
        List<AttributeModifier> toRemove = new ArrayList<>(modifiers);
        for (AttributeModifier modifier : toRemove) {
            removeModifier(modifier);
        }
    }
    
    /**
     * 添加属性变化监听器
     */
    public void addListener(AttributeListener listener) {
        if (listener != null) {
            listeners.add(listener);
        }
    }
    
    /**
     * 移除属性变化监听器
     */
    public void removeListener(AttributeListener listener) {
        listeners.remove(listener);
    }
    
    /**
     * 获取所有属性的字符串描述
     */
    public String getAttributesSummary() {
        StringBuilder sb = new StringBuilder();
        sb.append("属性总览:\n");
        
        // 基础属性
        sb.append(String.format("  等级: %d, 经验: %d\n", 
            getAttributeAsInt(AttributeType.LEVEL), 
            getAttributeAsInt(AttributeType.EXPERIENCE)));
        
        // 生命和魔力
        sb.append(String.format("  HP: %d/%d (恢复: %.1f/s)\n", 
            getAttributeAsInt(AttributeType.CURRENT_HEALTH),
            getAttributeAsInt(AttributeType.MAX_HEALTH),
            getAttribute(AttributeType.HEALTH_RECOVER_RATE)));
        
        sb.append(String.format("  魔力: %d/%d (恢复: %.1f/s)\n", 
            getAttributeAsInt(AttributeType.CURRENT_MANA),
            getAttributeAsInt(AttributeType.MAX_MANA),
            getAttribute(AttributeType.MANA_RECOVER_RATE)));
        
        // 攻防速
        sb.append(String.format("  攻击: %.1f, 防御: %.1f, 速度: %.1f\n", 
            getAttribute(AttributeType.ATTACK),
            getAttribute(AttributeType.DEFENSE),
            getAttribute(AttributeType.SPEED)));
        
        // 战斗属性
        sb.append(String.format("  暴击: %.1f%%, 伤害: %.1f%%\n", 
            getAttribute(AttributeType.CRITICAL_RATE) * 100,
            getAttribute(AttributeType.CRITICAL_DAMAGE) * 100));
        
        // 资源
        sb.append(String.format("  金币: %d, 宝石: %d\n", 
            getAttributeAsInt(AttributeType.GOLD),
            getAttributeAsInt(AttributeType.GEMS)));
        
        return sb.toString();
    }
    
    /**
     * 通知属性变化
     */
    private void notifyAttributeChanged(AttributeType type, double oldValue, double newValue) {
        for (AttributeListener listener : listeners) {
            try {
                listener.onAttributeChanged(type, oldValue, newValue);
            } catch (Exception e) {
                log.error("属性变化监听器异常", e);
            }
        }
    }
    
    /**
     * 通知修改器应用
     */
    private void notifyModifierApplied(AttributeModifier modifier, boolean applied) {
        for (AttributeListener listener : listeners) {
            try {
                listener.onModifierApplied(modifier, applied);
            } catch (Exception e) {
                log.error("修改器应用监听器异常", e);
            }
        }
    }
    
    /**
     * 获取对象ID
     */
    public long getObjectId() {
        return objectId;
    }
    
    /**
     * 获取所有属性
     */
    public Map<AttributeType, AttributeValue> getAllAttributes() {
        return new HashMap<>(attributes);
    }
}
